package com.dingding.common.core.util;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

/**
 * 
 * @ClassName: DateFormat
 * @Description: 时间格式化类
 * @author cheshaowei
 * @date 2015-9-29 下午03:59:51
 */
public class DateFormatUtil {

	private static SimpleDateFormat dateFormat = new SimpleDateFormat();

	private static final Logger log = Logger.getLogger(DateFormatUtil.class);

	/**
	 * 
	 * 格式化为ISO 8601标准日期时间格式 当前格式为 “yyyy-MM-dd HH:mm:ss”
	 * 
	 */
	private static final String ISO_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

	/**
	 * 
	 * 格式化为ISO 8601标准日期时间格式 当前格式为 “yy年MM月dd日 HH时”
	 * 
	 */
	private static final String ISO_DATETIME_FORMAT_CN_ = "yy年MM月dd日";
	
	/**
	 * 
	 * 格式化为ISO 8601标准日期时间格式 当前格式为 “yyyy年MM月dd日 HH时mm分ss秒”
	 * 
	 */
	private static final String ISO_DATETIME_FORMAT_CN = "yyyy年MM月dd日 HH时";

	/**
	 * 
	 * 格式化为ISO 8601标准日期时间格式 当前格式为 “yyyy年MM月dd日 HH时mm分ss秒”
	 * 
	 */
	private static final String ISO_DATETIME_PARSE_CN = "yyyy年MM月dd日 HH时mm分";

	/**
	 * 
	 * 格式化为ISO 8601标准日期时间格式 当前格式为 “yyyy-MM-dd HH:mm”
	 * 
	 */
	private static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm";

	/**
	 * 
	 * 格式化为ISO 8601标准日期格式 当前格式为 “yyyy-MM-dd”
	 * 
	 */
	private static final String ISO_DATE_FORMAT = "yyyy-MM-dd";

	/**
	 * 
	 * 格式化为ISO 8601标准时间格式 当前格式为 “HH:mm”
	 * 
	 */
	private static final String ISO_TIME_FORMAT = "HH:mm";

	/**
	 * 格式化为ISO 8601标准时间格式 当前格式为 “HH:mm:ss”
	 */
	private static final String ISO_TIMEHHSSMM_FORMAT = "HH:mm:ss";

	/**
	 * 
	 * 将文本类型时间转换成标准的日期时间格式 当前使用格式为：yyyy-MM-dd HH:mm:ss
	 * 
	 * @Title: yyyy_MM_dd_HHmmss
	 * @param text
	 *            待转换的时间文本 不能为空
	 * @return Date 转换后的标准时间格式
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static Date yyyy_MM_dd_HHmmss(String text) {

		if (StringUtils.isBlank(text)) {
			return null;
		}

		Date date = null;
		try {
			dateFormat.applyPattern(DateFormatUtil.ISO_DATETIME_FORMAT);
			date = dateFormat.parse(text);
		} catch (ParseException e) {
			log.error("将文本时间类型转换成标准时间类型出现异常！", e);
		}

		return date;

	}

	/**
	 * 
	 * 将文本类型时间转换成标准的日期时间格式 当前使用格式为：yyyy-MM-dd HH:mm:ss
	 * 
	 * @Title: yyyy_MM_dd_HHmmss
	 * @param text
	 *            待转换的时间文本 不能为空
	 * @return Date 转换后的标准时间格式
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static Date yyyy_MM_dd_HHmm(String text) {

		if (StringUtils.isBlank(text)) {
			return null;
		}

		Date date = null;
		try {
			dateFormat.applyPattern(DateFormatUtil.DATETIME_FORMAT);
			date = dateFormat.parse(text);
		} catch (ParseException e) {
			log.error("将文本时间类型转换成标准时间类型出现异常！", e);
		}

		return date;

	}

	/**
	 * 
	 * 将文本类型时间转换成标准的中文日期时间格式
	 * 
	 * 当前使用格式为：yyyy年MM月dd日 HH时mm分ss秒
	 * 
	 * @Title: yyyy_MM_dd_HHmm_CN
	 * @param parseDate
	 *            待转换的时间
	 * @return String 转换后的文本时间
	 * @author CHEHAUNBO
	 * @since V2.4.0
	 * 
	 */
	public synchronized static String yyyy_MM_dd_HHmm_CN(Date parseDate) {

		if (parseDate == null) {
			return null;
		}

		dateFormat.applyPattern(DateFormatUtil.ISO_DATETIME_FORMAT_CN);
		return dateFormat.format(parseDate);

	}

	
	/**
	 * 
	 * 将文本类型时间转换成标准的中文日期时间格式
	 * 
	 * 当前使用格式为：yyyy年MM月dd日 HH时mm分ss秒
	 * 
	 * @Title: yyyy_MM_dd_HHmm_CN
	 * @param parseDate
	 *            待转换的时间
	 * @return String 转换后的文本时间
	 * @author CHEHAUNBO
	 * @since V2.4.0
	 * 
	 */
	public synchronized static Date yyyy_MM_dd_HHmm_CN(String dateText) {

		if (ToolUtil.isBlank(dateText)) {
			return null;
		}

		try {
			dateFormat.applyPattern(DateFormatUtil.ISO_DATETIME_PARSE_CN);
			return dateFormat.parse(dateText);
		} catch (ParseException e) {
			log.error("文本时间转换成标准时间出现异常！" + dateText, e);
			e.printStackTrace();
		}

		return null;

	}

	/**
	 * 
	 * 将当前系统日期时间转换成指定格式的文本类型日期时间(yyyy-MM-dd HH:mm:ss)
	 * 
	 * @Title yyyy_MM_dd_HHmmss
	 * @return String 转换后的文本类型的系统日期时间
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static String yyyy_MM_dd_HHmmss() {

		String date = null;

		try {

			dateFormat.applyPattern(DateFormatUtil.ISO_DATETIME_FORMAT);
			date = dateFormat.format(new Date());

		} catch (Exception e) {
			log.error("将当前系统时间转换成指定格式的文本类型时间出现异常！", e);
		}

		return date;

	}

	/**
	 * 
	 * 将当前系统日期时间转换成指定格式的文本类型日期时间(yyyy-MM-dd HH:mm:ss)
	 * 
	 * @Title yyyy_MM_dd_HHmmss
	 * @return String 转换后的文本类型的系统日期时间
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static String yyyy_MM_dd_HHmmss(Date date) {

		String temp = null;
		try {

			dateFormat.applyPattern(DateFormatUtil.ISO_DATETIME_FORMAT);
			temp = dateFormat.format(date);

		} catch (Exception e) {
			log.error("将当前系统时间转换成指定格式的文本类型时间出现异常！", e);
		}

		return temp;

	}

	/**
	 * 
	 * @Title: yy_MM_dd_HHmmss 
	 * @Description: 将当前系统日期时间转换成指定格式的文本类型日期时间(yy年MM月dd日)
	 * @param date 要转换格式的时间
	 * @author YHQ 
	 * @since V2.6.3
	 * @return String    返回类型
	 * 
	 */
	public synchronized static String yy_MM_dd_HHmmss(Date date) {

		String temp = null;
		try {

			dateFormat.applyPattern(DateFormatUtil.ISO_DATETIME_FORMAT_CN_);
			temp = dateFormat.format(date);

		} catch (Exception e) {
			log.error("将当前系统时间转换成指定格式的文本类型时间出现异常！", e);
		}

		return temp;

	}
	
	public static void main(String[] args) {
		
		SimpleDateFormat dateFormat = new SimpleDateFormat("yy年MM月dd日");
		
		System.out.println(dateFormat.format(new Date()));
		
	}
	
	/**
	 * 
	 * 将当前系统日期时间转换成指定格式的文本类型日期时间(yyyy-MM-dd HH:mm)
	 * 
	 * @Title yyyy_MM_dd_HHmm
	 * @return String 转换后的文本类型的系统日期时间
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static String yyyy_MM_dd_HHmm(Date date) {

		String dateStr = null;

		try {

			dateFormat.applyPattern(DateFormatUtil.DATETIME_FORMAT);
			dateStr = dateFormat.format(date);

		} catch (Exception e) {
			log.error("将当前系统时间转换成指定格式的文本类型时间出现异常！", e);
		}

		return dateStr;

	}

	/**
	 * @Description:把指定时间转化为时分秒格式
	 * @author fengshuonan
	 * @since 2.4
	 */
	public synchronized static String HHmmSS(Date date) {
		String dateStr = null;
		try {
			dateFormat.applyPattern(DateFormatUtil.ISO_TIMEHHSSMM_FORMAT);
			dateStr = dateFormat.format(date);
		} catch (Exception e) {
			log.error("将当前系统时间转换成指定格式的文本类型时间出现异常！", e);
		}
		return dateStr;

	}

	/**
	 * 
	 * 将当前系统日期转换成指定格式的文本类型日期(yyyy-MM-dd)
	 * 
	 * @Title yyyy_MM_dd
	 * @return String 转换后的文本类型的系统日期
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static String yyyy_MM_dd() {

		// 获取格式化后的时间字符串
		String formateDate = null;

		try {
			dateFormat.applyPattern(DateFormatUtil.ISO_DATE_FORMAT);
			formateDate = dateFormat.format(new Date());

		} catch (Exception e) {
			log.error("将当前系统日期转换成指定格式的文本类型日期出现异常！", e);
		}

		return formateDate;
	}

	/**
	 * 
	 * 将当前系统日期转换成指定格式的文本类型日期(yyyy-MM-dd)
	 * 
	 * @Title yyyy_MM_dd
	 * @return String 转换后的文本类型的系统日期
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static String yyyy_MM_dd(Date date) {

		// 获取格式化后的时间字符串
		String formateDate = null;

		try {
			dateFormat.applyPattern(DateFormatUtil.ISO_DATE_FORMAT);
			formateDate = dateFormat.format(date);

		} catch (Exception e) {
			log.error("将当前系统日期转换成指定格式的文本类型日期出现异常！", e);
		}

		return formateDate;
	}
	
	/**
	 * @Description: 获取指定格式的date
	 * @author fengshuonan
	 * @return Date
	 */
	public synchronized static Date yyyy_MM_ddDate(Date date) {

		dateFormat.applyPattern(DateFormatUtil.ISO_DATE_FORMAT);
		String dateStr = dateFormat.format(date);

		Date after = null;

		try {
			after = dateFormat.parse(dateStr);
		} catch (ParseException e) {
			log.error("将文本类型时间转换成标准时间出现异常！", e);
		}

		return after;
	}

	/**
	 * 
	 * 将文本类型时间转换成标准时间(HH:mm)
	 * 
	 * @Title: HH:mm
	 * @param text
	 *            待转换的文本时间 不能为空
	 * @return Date 转换后的标准时间
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static Date HHmm(String text) {

		if (StringUtils.isBlank(text)) {
			return null;
		}

		Date date = null;
		try {
			dateFormat.applyPattern(DateFormatUtil.ISO_TIME_FORMAT);
			date = dateFormat.parse(text);
		} catch (ParseException e) {
			log.error("将文本类型时间转换成标准时间出现异常！", e);
		}

		return date;
	}

	public synchronized static String yyyy_Year_MM_Month_dd(String text) {

		if (ToolUtil.isBlank(text)) {
			return null;
		}
		Date date = null;
		String formatText = null;
		try {
			dateFormat.applyPattern("yyyy-MM-dd");
			date = dateFormat.parse(text);
			formatText = dateFormat.format(date);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return formatText;

	}

	/**
	 * 
	 * 获取系统当前时间戳
	 * 
	 * @Title: getTimeInMillis
	 * @return long 获取到的当前系统时间差
	 * @author CHEHUANBO
	 * 
	 */
	public synchronized static Long getTimeInMillis() {
		return Calendar.getInstance().getTimeInMillis();
	}

	/**
	 * 
	 * 获取指定时间的时间戳
	 * 
	 * @Title: getTimeInMillisByTime
	 * @return long 获取到的当前系统时间差
	 * @author CHEHUANBO
	 * 
	 */
	public synchronized static Long getTimeInMillisByTime(Date date) {

		Calendar cal = Calendar.getInstance();

		cal.setTime(date);

		long timestamp = cal.getTimeInMillis();

		return timestamp;
	}

	/**
	 * 
	 * 通过时间转为 xx月xx日（周X） xx:xx
	 * 
	 * @Title: getMMddEHHss
	 * @param obj
	 *            待转换的时间对象 不能为空
	 * @return String 转换后的日期时间
	 * @author CHEHAUNBO
	 * 
	 */
	public synchronized static String getMMddEHHss(Object obj) {

		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

		if (obj == null) {
			return null;
		}

		Date date = (Date) obj;
		String dayNames[] = { "日", "一", "二", "三", "四", "五", "六" };
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		if (dayOfWeek < 0) {
			dayOfWeek = 0;
		}

		String str = simpleDateFormat.format(date);
		StringBuffer myStr = new StringBuffer();

		myStr.append(str.substring(5, 7));
		myStr.append("月");
		myStr.append(str.substring(8, 10));
		myStr.append("日(周");
		myStr.append(dayNames[dayOfWeek]);
		myStr.append(") ");
		myStr.append(str.substring(11, 16));

		return myStr.toString();

	}

	/**
	 * @Description:将时间对象转化为HH：mm
	 * @param date
	 *            时间对象
	 * @author fengshuonan
	 * @return String
	 */
	public static String getHHmm(Date date) {

		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(ISO_TIME_FORMAT);

		return simpleDateFormat.format(date);
	}

	/**
	 * 
	 * @Title: isClientTimeTrue
	 * @Description: 验证客户端传的订单出发时间是否合理 出发时间不能早于系统当前时间，并且不能大于超过系统当前时间48小时
	 * @param setOutTime
	 *            订单的出发时间
	 * @return true 客户端传值不正确 false 传的时间正确 @throws
	 * 
	 */
	public synchronized static boolean isClientTimeNotTrue(String setOutTime) {

		// 出发时间
		Date clientTime = yyyy_MM_dd_HHmmss(setOutTime);
		Calendar rightNow_1 = Calendar.getInstance();
		rightNow_1.setTime(clientTime);

		// 获取系统当前时间
		Date currdentTime = new Date();
		Calendar rightNow_2 = Calendar.getInstance();
		rightNow_2.setTime(currdentTime);

		// 出发时间低于当前时间或者大于（当前时间+2day） 均为不合理
		Calendar rightNow_3 = Calendar.getInstance();
		rightNow_3.setTime(currdentTime);
		rightNow_3.add(Calendar.DATE, 60);

		// 当前时间 > 出发时间 当前时间+2天 < 出发时间
		return rightNow_2.after(rightNow_1) || rightNow_3.before(rightNow_1);

	}

	/**
	 * 
	 * 获取两个时间之间的间隔 单位：分钟
	 * 
	 * @Title: getTimeInterval
	 * @param date_one
	 *            第一个时间 不为空
	 * @param date_two
	 *            第二个时间 不为空
	 * @return long 获取到的时间差
	 * @author CHEHUANBO
	 * @throws ParseException
	 * 
	 */
	public synchronized static long getTimeIntervalS(Date date_one, Date date_two) throws ParseException {

//		long nd = 1000 * 24 * 60 * 60;
//		long nh = 1000 * 60 * 60;
//		long nm = 1000 * 60;

		// 获取订单的出发日期的时分秒
		SimpleDateFormat dfu = new SimpleDateFormat("HH:mm:ss");

		// 创建Calendar对象
		Calendar userCalendar = Calendar.getInstance();
		Calendar orderCalendar = Calendar.getInstance();

		// 获取订单日期的时分秒，并赋值给orderCalendar
		orderCalendar.setTime(dfu.parse(dfu.format(date_two)));

		// 将用户的出发时间赋值给userCalendar
		userCalendar.setTime(date_one);

		// 两个时间差
		long number = Math.abs(Math.abs(orderCalendar.getTimeInMillis()) - Math.abs(userCalendar.getTimeInMillis()));

		return number / (1000 * 60);

	}

	/**
	 * 
	 * 获取两个时间差的分钟数
	 * 
	 * 最大范围是"小时"级别
	 * 
	 * @Title: dateMin
	 * @param startTime
	 *            开始时间
	 * @param endTime
	 *            结束时间
	 * @return int
	 * @author CHEHAUNBO
	 * @since V2.4.0
	 * 
	 */
	public static BigDecimal dateMin(Date startTime, Date endTime) {

		int diff = (int) (startTime.getTime() - endTime.getTime());// 获得两个时间的毫秒时间差异
		int nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
		int nh = 1000 * 60 * 60;// 一小时的毫秒数
		int nm = 1000 * 60;// 一分钟的毫秒数
		int hour = diff % nd / nh;// 计算差多少小时
		int min = diff % nd % nh / nm;// 计算差多少分钟
		return new BigDecimal((Math.abs(hour) * 60) + Math.abs(min));

	}

	/**
	 * 
	 * 将秒转换成分钟
	 * 
	 * 
	 * @Title: dateMin
	 * @param second
	 *            待转换的秒数
	 * @return int 转换后的分钟数
	 * @author CHEHAUNBO
	 * @since V2.4.0
	 * 
	 */
	public static int dateSecondToMin(int second) {

		return (Math.abs(second / 60));

	}

	/**
	 * 
	 * 计算两个时间的小时差
	 * 
	 * @Title: dateHH
	 * @param startTime
	 *            开始时间
	 * @param endTime
	 *            结束时间
	 * @author CHEHAUNBO
	 * @since V2.4.0
	 * 
	 */
	public static Double dateHH(Date startTime, Date endTime) {

		int diff = (int) (startTime.getTime() - endTime.getTime());// 获得两个时间的毫秒时间差异
		int nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
		int nh = 1000 * 60 * 60;// 一小时的毫秒数
		int nm = 1000 * 60;// 一分钟的毫秒数
		int hour = diff % nd / nh;// 计算差多少小时
		int min = diff % nd % nh / nm;// 计算差多少分钟
		DecimalFormat df = new DecimalFormat("0.0");// 格式化小数
		String hh = df.format((double) min / 60);
		return Math.abs(hour) + (Double.parseDouble(hh));

	}

	/**
	 * 
	 * 获取两个时间之间的间隔 单位：小时
	 * 
	 * @Title: getTimeInterval
	 * @param date_one
	 *            第一个时间 不为空
	 * @param date_two
	 *            第二个时间 不为空
	 * @return long 获取到的时间差
	 * @author CHEHUANBO
	 * @throws ParseException
	 * 
	 */
	public synchronized static long getTimeIntervalHour(Date date_one, Date date_two) {

		long time = 0;
		try {
			time = DateFormatUtil.getTimeIntervalS(date_one, date_two);
		} catch (ParseException e) {
			log.error("获取时间差出现异常！", e);
		}

		return (time % (60 * 60 * 24)) / (1000 * 60 * 60);

	}

	/**
	 * 
	 * 判断当期日期是否为周末
	 * 
	 * @Title: isWeekend
	 * @param currentDate
	 *            当前日期 不能为空
	 * @return boolean true:是 false:不是
	 * @author CHEHUANBO
	 * 
	 */
	public synchronized static boolean isWeekend(Date currentDate) {

		Calendar calendar = Calendar.getInstance();
		// 设置日期
		calendar.setTime(currentDate);
		int week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		if (week == 6 || week == 0) {// 0代表周日，6代表周六
			return true;
		} else {
			return false;
		}

	}

	/**
	 * @Title: millisecondToDate
	 * @Description: 将毫秒转为日期格式（年月日时分秒）
	 * @param @param
	 *            millisecond
	 * @param @return
	 *            设定文件
	 * @author YHQ
	 * @return String 返回类型
	 */
	public synchronized static Date millisecondToDate(long millisecond) {

		Date date = null;

		Calendar calendar = Calendar.getInstance();
		// 设置毫秒数
		calendar.setTimeInMillis(millisecond);

		// 获取年份
		int year = calendar.get(Calendar.YEAR);

		// 获取月份
		int month = calendar.get(Calendar.MONTH) + 1;
		String mToMonth = null;
		if (String.valueOf(month).length() == 1) {
			mToMonth = "0" + month;
		} else {
			mToMonth = String.valueOf(month);
		}

		// 获取天
		int day = calendar.get(Calendar.DAY_OF_MONTH);
		String dToDay = null;
		if (String.valueOf(day).length() == 1) {
			dToDay = "0" + day;
		} else {
			dToDay = String.valueOf(day);
		}

		// 获取小时
		int hour = calendar.get(Calendar.HOUR_OF_DAY);
		String hToHour = null;
		if (String.valueOf(hour).length() == 1) {
			hToHour = "0" + hour;
		} else {
			hToHour = String.valueOf(hour);
		}

		// 获取分钟
		int minute = calendar.get(Calendar.MINUTE);
		String mToMinute = null;
		if (String.valueOf(minute).length() == 1) {
			mToMinute = "0" + minute;
		} else {
			mToMinute = String.valueOf(minute);
		}

		// 获取秒
		int second = calendar.get(Calendar.SECOND);
		String sToSecond = null;
		if (String.valueOf(second).length() == 1) {
			sToSecond = "0" + second;
		} else {
			sToSecond = String.valueOf(second);
		}

		String dateStr = year + "-" + mToMonth + "-" + dToDay + " " + hToHour + ":" + mToMinute + ":" + sToSecond;

		dateFormat.applyPattern(DateFormatUtil.ISO_DATETIME_FORMAT);

		try {
			date = dateFormat.parse(dateStr);
		} catch (ParseException e) {
			log.error("将毫秒转为日期格式（年月日时分秒）时出现异常", e);
		}

		return date;
	}

	/**
	 * 
	 * @Title: isSameDate
	 * @Description: 判断两个时间点是不是同一天
	 * @param date1
	 * @param date2
	 * @author YHQ
	 * @return boolean 返回类型
	 * 
	 */
	public synchronized static boolean isSameDate(Date date1, Date date2) {
		Calendar cal1 = Calendar.getInstance();
		cal1.setTime(date1);

		Calendar cal2 = Calendar.getInstance();
		cal2.setTime(date2);

		boolean isSameYear = cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR);
		boolean isSameMonth = isSameYear && cal1.get(Calendar.MONTH) == cal2.get(Calendar.MONTH);
		boolean isSameDate = isSameMonth && cal1.get(Calendar.DAY_OF_MONTH) == cal2.get(Calendar.DAY_OF_MONTH);

		return isSameDate;
	}

	/**
	 * @Description:获取两个时间的间隔
	 * @author fengshuonan
	 * @return int 时间的间隔（单位：分钟）
	 * @since 2.4
	 */
	public static int getDateTimeDifference(Date date1, Date date2) {

		long date1TimeStap = date1.getTime();
		long date2TimeStap = date2.getTime();

		if (date1TimeStap > date2TimeStap) {
			return (int) ((date1TimeStap - date2TimeStap) / 1000 / 60);
		} else {
			return (int) ((date2TimeStap - date1TimeStap) / 1000 / 60);
		}
	}

	/**
	 * @Description:获取两个时间的间隔
	 * @author YHQ
	 * @return int 时间的间隔（单位：秒）
	 * @since 5.6.7
	 */
	public static int getDateTimeDifferenceBySecond(Date date1, Date date2) {

		long date1TimeStap = date1.getTime();
		long date2TimeStap = date2.getTime();

		if (date1TimeStap > date2TimeStap) {
			return (int) ((date1TimeStap - date2TimeStap) / 1000);
		} else {
			return (int) ((date2TimeStap - date1TimeStap) / 1000);
		}
	}

	/**
	 * @Description:解析类似08月25日(周四) 21:12的日期转化为Date格式
	 * @author fengshuonan
	 * @since 2.4
	 */
	public static Date parseMMddWWHHSS(String date) {

		String mon = date.substring(0, 2);
		String day = date.substring(date.indexOf("月") + 1, date.indexOf("日"));
		String time = date.substring(date.indexOf(" ") + 1);
		Calendar calendar = Calendar.getInstance();
		int year = calendar.get(Calendar.YEAR);

		StringBuilder builder = new StringBuilder();
		builder = builder.append(year);
		builder = builder.append("-");
		builder = builder.append(mon);
		builder = builder.append("-");
		builder = builder.append(day);
		builder = builder.append(" ");
		builder = builder.append(time);

		return DateFormatUtil.yyyy_MM_dd_HHmm(builder.toString());
	}

	/**
	 * @Description:解析类似2016-11-11的日期转化为Date格式
	 * @author fengshuonan
	 * @since 2.4
	 */
	public static Date parseYyMmDd(String date) {
		date = date + " 00:00";
		return DateFormatUtil.yyyy_MM_dd_HHmm(date);
	}

	/**
	 * 
	 * @Description: 计算驾龄
	 * @author YHQ
	 * @since 2.5.6
	 */
	public static int getDriving(String date) {

		int number = 0;

		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

			Calendar cal = Calendar.getInstance();
			cal.setTime(sdf.parse(sdf.format(parseYyMmDd(date))));
			long time1 = cal.getTimeInMillis();

			cal.setTime(sdf.parse(sdf.format(new Date())));
			long time2 = cal.getTimeInMillis();
			long between_days = (time2 - time1) / (1000 * 3600 * 24);

			float str = (float) between_days / (float) 365;

			if (str > 0 && str <= 1) {
				number = 1;
			} else if (str > 1) {

				number = (int) Math.floor(Double.valueOf(str));
			}

		} catch (ParseException e) {
			e.printStackTrace();
		}
		return number;
	}

	/**
	 * 
	 * @Title: compareDate
	 * @Description: 比较两个时间点大小
	 * @param date1
	 *            第一个时间点
	 * @param date2
	 *            第二个时间点
	 * @author YHQ
	 * @return int 0:相等 1:大于 -1:小于
	 * 
	 */
	public synchronized static int compareDate(Date date1, Date date2) {

		if (date1.getTime() > date2.getTime()) { // 大于
			return 1;
		} else if (date1.getTime() < date2.getTime()) { // 小于
			return -1;
		} else { // 相等

			return 0;
		}
	}

	/**
	 * 
	 * @Title: intervalDay
	 * @Description: 获取俩时间之间间隔天数
	 * @param @return
	 *            设定文件
	 * @author YHQ
	 * @return int 返回类型
	 */
	public static int intervalDay(Date startTime, Date endTime) {

		Calendar aCalendar = Calendar.getInstance();

		aCalendar.setTime(startTime);

		int day1 = aCalendar.get(Calendar.DAY_OF_YEAR);

		aCalendar.setTime(endTime);

		int day2 = aCalendar.get(Calendar.DAY_OF_YEAR);

		return Math.abs(day2 - day1);
	}

	/**
	 * 
	 * @Title: plusOneDay 
	 * @Description: 给日期增加一天
	 * @param date 要增加天数的日期
	 * @author YHQ 
	 * @since V2.5.7
	 * @return Date    返回类型
	 * 
	 */
	public static Date plusOneDay(Date date){
		
		Calendar c = Calendar.getInstance();
        
		c.setTime(date);
		
        c.add(Calendar.DAY_OF_MONTH, 1);
		
		return c.getTime();
	}
	
	/**
	 * 
	 * 将文本类型时间转换成标准的中文日期时间格式 
	 * 
	 * 当前使用格式为：yyyy年MM月dd日
	 * 
	 * @Title: yyyy_MM_dd_HH
	 * @param parseDate
	 *            待转换的时间
	 * @return String 转换后的文本时间
	 * @author hufan
	 * @since V2.5.7
	 * 
	 */
	public synchronized static String yyyy_MM_dd_HH(Date parseDate) {

		if (parseDate == null) {
			return null;
		}

		dateFormat.applyPattern(DateFormatUtil.ISO_DATE_FORMAT);
		return dateFormat.format(parseDate);

	}
	
	/**
	 * 
	 * @Title: yyyy_MM_dd 
	 * @Description: TODO
	 * @param @param text
	 * @param @return  参数说明 
	 * @return Date    返回类型 
	 * @throws
	 */
	public synchronized static Date yyyy_MM_dd(String text) {

		if (StringUtils.isBlank(text)) {
			return null;
		}

		Date date = null;
		try {
			dateFormat.applyPattern(DateFormatUtil.ISO_DATE_FORMAT);
			date = dateFormat.parse(text);
		} catch (ParseException e) {
			log.error("将文本时间类型转换成标准时间类型出现异常！", e);
		}

		return date;

	}
	
	/**
	 * 
	 * @Title: getNightTime 
	 * @Description: 将任意两个时间的日期和时间拼装成一个新的Date
	 * @param date 提供日期
	 * @param time 提供时间
	 * @author YHQ 
	 * @return Date    返回类型
	 */
	public static Date getNightTime(Date date,Date time){
		
		return DateFormatUtil.yyyy_MM_dd_HHmmss(DateFormatUtil.yyyy_MM_dd(date) + " " + DateFormatUtil.HHmmSS(time));
	}
	
}
